// pages/contract/index.js
Page({
  data: {
    contractId: '', // 合同ID
    showSignature: false, // 是否显示签名画布
    ctx: null, // 画布上下文
    canvasWidth: 0, // 画布宽度
    canvasHeight: 0, // 画布高度
    points: [], // 签名点集合
    signatureMode: '', // 当前签名模式 landlord/tenant
    landlordSignatureTempPath: '',
    landlordSignaturePreview: '',
    isSubmitting: false,
    contractCreated: false,
    createdContractId: '',
    roomItems: [], // 房间物品列表
    showSaveButton: true, // 是否显示保存按钮（截图时隐藏）
    // 合同数据变量（后期将通过云函数获取）
    contractData: {
      // 甲方（房东）信息
      landlordName: '未填写',
      landlordPhone: '未填写',
      landlordIdCard: '未填写',
      landlordAddress: '未填写',
      
      // 乙方（租客）信息
      tenantName: '未填写',
      tenantPhone: '未填写',
      tenantIdCard: '未填写',
      tenantAddress: '未填写',
      
      // 房屋信息
      province: '四川省',
      city: '成都市',
      district: '新都区',
      street: '斑竹园街道',
      address: '鸿发路488号1栋17层',
      room: '', // 室号
      area: '', // 建筑面积（平方米）
      roomType: '', // 户型：一室一厅一卫、两室一厅一卫
      
      // 租赁期限
      startYear: '', // 开始年份
      startMonth: '', // 开始月份
      startDay: '', // 开始日期
      endYear: '', // 结束年份
      endMonth: '', // 结束月份
      endDay: '', // 结束日期
      renewNoticeMonths: '', // 续租提前通知月数
      
      // 租金信息
      monthlyRent: '', // 月租金（数字）
      monthlyRentUpper: '', // 月租金大写
      paymentMethod: '', // 支付方式（月付/季付/年付）
      paymentDaysBefore: '', // 支付周期开始前几日
      lateFeePercent: '', // 逾期违约金百分比
      
      // 押金信息
      deposit: '', // 押金（数字）
      depositUpper: '', // 押金大写
      
      // 交付日期
      deliveryYear: '', // 交付年份
      deliveryMonth: '', // 交付月份
      deliveryDay: '', // 交付日期
      
      // 合同解除相关
      overdueDays: '', // 逾期天数
      overdueAmount: '', // 欠缴费用金额
      
      // 违约责任
      penaltyAmount: '', // 违约金金额（数字）
      penaltyAmountUpper: '' // 违约金大写
    }
  },

  async onLoad(options) {
    // 记录流程类型：tenant（租客流程）、landlord（房东流程）、view（查看模式）
    const flow = options.flow || 'landlord';
    this.setData({ flow: flow });
    
    // 获取系统信息，用于设置画布大小（租客流程需要，横向布局）
    if (flow === 'tenant') {
      wx.getSystemInfo({
        success: (res) => {
          // 横向布局：画布宽度 = 屏幕高度 - 头部高度，画布高度 = 屏幕宽度 - 按钮宽度
          this.setData({
            canvasWidth: res.windowHeight - 120, // 屏幕高度减去头部高度
            canvasHeight: res.windowWidth - 120  // 屏幕宽度减去按钮宽度
          });
        }
      });
    }
    
    // 如果是从合同详情页面进入（查看模式），通过 contractId 加载完整数据
    if (flow === 'view' && options.contractId) {
      this.setData({ contractId: options.contractId });
      await this.loadContractData();
    }
    // 如果从承租人信息页面传递了数据（房东流程），则使用传递的数据
    else if (options.data && flow === 'landlord') {
      try {
        const contractData = JSON.parse(decodeURIComponent(options.data));
        this.setData({
          contractData: contractData
        });
        console.log('合同数据已加载:', contractData);
      } catch (e) {
        console.error('解析合同数据失败:', e);
        wx.showToast({
          title: '数据加载失败',
          icon: 'none'
        });
      }
    }
    // 租客流程，通过 contractId 加载合同数据
    else if (options.contractId && flow === 'tenant') {
      this.setData({ contractId: options.contractId });
      await this.loadContractData();
    }
  },
  
  // 页面显示时重新加载数据（用于从签名页面返回时刷新）
  async onShow() {
    // 如果是租客流程且有合同ID，重新加载数据
    if (this.data.flow === 'tenant' && this.data.contractId) {
      await this.loadContractData();
    }
  },

  // 加载合同数据
  async loadContractData() {
    wx.showLoading({
      title: '加载中...',
      mask: true
    });
    
    try {
      const res = await wx.cloud.callFunction({
        name: 'contract',
        data: {
          apiType: 'getContractInfo',
          contractId: this.data.contractId
        }
      });

      wx.hideLoading();

      if (res.result.res.code === 200) {
        const contractData = res.result.res.data;
        const updates = {
          contractData: contractData
        };

        // 保存房间物品数据（如果存在）
        if (contractData.roomItems && Array.isArray(contractData.roomItems)) {
          updates.roomItems = contractData.roomItems;
        }

        // 根据不同的流程类型设置不同的数据
        if (this.data.flow === 'landlord') {
          // 房东流程：只处理房东签字
          if (contractData.landlordSignature) {
            updates.landlordSignaturePreview = contractData.landlordSignature;
          }
          if (contractData._id) {
            updates.contractId = contractData._id;
            updates.contractCreated = true;
            updates.createdContractId = contractData._id;
          }
        } else if (this.data.flow === 'tenant') {
          // 租客流程：处理租客签字，同时显示房东签字图片
          // contractData 已经包含 tenantSignature
          if (contractData.landlordSignature) {
            updates.landlordSignaturePreview = contractData.landlordSignature;
          }
        } else if (this.data.flow === 'view') {
          // 查看模式：显示房东和租客的签字图片
          if (contractData.landlordSignature) {
            updates.landlordSignaturePreview = contractData.landlordSignature;
          }
        }

        this.setData(updates);
        console.log('合同数据已加载:', contractData);
      } else {
        wx.showToast({
          title: res.result.res.msg || '加载失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('加载合同数据失败:', error);
      wx.hideLoading();
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      });
    }
  },
  
  // 保存合同（租客流程中，查看合同后保存）
  async saveContract() {
    if (!this.data.contractId) {
      return;
    }
    
    wx.showLoading({
      title: '保存中...',
      mask: true
    });
    
    try {
      // 这里可以保存一些状态，比如"已查看合同"
      // 目前合同数据已经在租客信息页面保存了，这里可以不做操作
      // 或者保存一个查看时间戳
      wx.hideLoading();
      wx.showToast({
        title: '已保存',
        icon: 'success'
      });
    } catch (error) {
      console.error('保存合同失败:', error);
      wx.hideLoading();
      wx.showToast({
        title: '保存失败',
        icon: 'none'
      });
    }
  },
  
  // 确认完成签约（租客流程最后一步）
  async confirmContract() {
    if (!this.data.contractId) {
      wx.showToast({
        title: '合同ID不存在',
        icon: 'none'
      });
      return;
    }
    
    wx.showModal({
      title: '确认完成',
      content: '确认完成合同签约吗？',
      success: async (res) => {
        if (res.confirm) {
          wx.showLoading({
            title: '提交中...',
            mask: true
          });
          
          try {
            // 获取房间物品数据
            let roomItems = [];
            const contractData = this.data.contractData || {};
            if (contractData.roomId) {
              try {
                const itemsRes = await wx.cloud.callFunction({
                  name: 'room',
                  data: {
                    apiType: 'getRoomItems',
                    roomId: contractData.roomId
                  }
                });
                if (itemsRes.result.res.code === 200) {
                  roomItems = itemsRes.result.res.data || [];
                }
              } catch (error) {
                console.error('获取房间物品失败:', error);
              }
            }
            
            const updateRes = await wx.cloud.callFunction({
              name: 'contract',
              data: {
                apiType: 'completeContract',
                contractId: this.data.contractId,
                status: 'active', // 激活合同
                roomItems: roomItems // 传递房间物品数据
              }
            });
            
            wx.hideLoading();
            
            if (updateRes.result.res.code === 200) {
              wx.showToast({
                title: '签约完成',
                icon: 'success'
              });
              
              // 返回工具页面
              setTimeout(() => {
                wx.navigateBack({
                  delta: 5 // 返回到工具页面
                });
              }, 1500);
            } else {
              wx.showToast({
                title: updateRes.result.res.msg || '提交失败',
                icon: 'none'
              });
            }
          } catch (error) {
            console.error('确认签约失败:', error);
            wx.hideLoading();
            wx.showToast({
              title: '提交失败，请重试',
              icon: 'none'
            });
          }
        }
      }
    });
  },

  // 房东确认发起签约
  async confirmInitiate() {
    if (this.data.flow !== 'landlord' || this.data.contractCreated) {
      return;
    }

    const contractData = this.data.contractData || {};
    if (!contractData.roomId) {
      wx.showToast({
        title: '房间信息缺失',
        icon: 'none'
      });
      return;
    }

    if (!this.data.landlordSignatureTempPath) {
      wx.showToast({
        title: '请先完成房东签字',
        icon: 'none'
      });
      return;
    }

    if (this.data.isSubmitting) {
      return;
    }

    this.setData({ isSubmitting: true });
    wx.showLoading({
      title: '正在创建合同...',
      mask: true
    });

    try {
      // 上传房东签名
      const fileExtension = this.data.landlordSignatureTempPath.split('.').pop();
      const cloudPath = `signatures/landlord-${Date.now()}-${Math.random().toString(36).substr(2, 9)}.${fileExtension}`;
      const uploadRes = await wx.cloud.uploadFile({
        cloudPath,
        filePath: this.data.landlordSignatureTempPath
      });
      const landlordSignatureUrl = uploadRes.fileID;

      const res = await wx.cloud.callFunction({
        name: 'contract',
        data: {
          apiType: 'addContract',
          roomId: contractData.roomId,
          landlordName: contractData.landlordName || '未填写',
          landlordPhone: contractData.landlordPhone || '未填写',
          landlordIdCard: contractData.landlordIdCard || '未填写',
          landlordAddress: contractData.landlordAddress || '未填写',
          landlordSignature: landlordSignatureUrl,
          tenantName: contractData.tenantName || '',
          tenantPhone: contractData.tenantPhone || '',
          tenantIdCard: contractData.tenantIdCard || '',
          tenantAddress: contractData.tenantAddress || '',
          startYear: contractData.startYear || '',
          startMonth: contractData.startMonth || '',
          startDay: contractData.startDay || '',
          endYear: contractData.endYear || '',
          endMonth: contractData.endMonth || '',
          endDay: contractData.endDay || '',
          renewNoticeMonths: contractData.renewNoticeMonths || '1',
          monthlyRent: contractData.monthlyRent || '',
          monthlyRentUpper: contractData.monthlyRentUpper || '',
          paymentMethod: contractData.paymentMethod || '',
          paymentDaysBefore: contractData.paymentDaysBefore || '3',
          lateFeePercent: contractData.lateFeePercent || '5',
          deposit: contractData.deposit || '',
          depositUpper: contractData.depositUpper || '',
          propertyFee: contractData.propertyFee || '',
          roomType: contractData.roomType || '',
          deliveryYear: contractData.deliveryYear || '',
          deliveryMonth: contractData.deliveryMonth || '',
          deliveryDay: contractData.deliveryDay || '',
          overdueDays: contractData.overdueDays || '15',
          overdueAmount: contractData.overdueAmount || '1000',
          penaltyAmount: contractData.penaltyAmount || '2000',
          penaltyAmountUpper: contractData.penaltyAmountUpper || ''
        }
      });

      wx.hideLoading();

      if (res.result.res.code === 200) {
        const contractId = res.result.res.data._id;

        try {
          await wx.cloud.callFunction({
            name: 'contract',
            data: {
              apiType: 'updateContractLandlordSignature',
              contractId: contractId,
              landlordSignature: landlordSignatureUrl
            }
          });
        } catch (signatureError) {
          console.error('保存房东签名失败:', signatureError);
          wx.showToast({
            title: '房东签名保存失败',
            icon: 'none'
          });
        }

        try {
          await wx.cloud.callFunction({
            name: 'contract',
            data: {
              apiType: 'markContractCreated',
              contractId: contractId
            }
          });
        } catch (statusError) {
          console.error('更新合同状态失败:', statusError);
        }

        this.setData({
          contractId,
          contractCreated: true,
          createdContractId: contractId,
          isSubmitting: false,
          landlordSignatureTempPath: '',
          landlordSignaturePreview: landlordSignatureUrl,
          contractData: {
            ...contractData,
            landlordSignature: landlordSignatureUrl
          }
        });

        wx.showToast({
          title: '合同创建成功',
          icon: 'success'
        });
      } else {
        throw new Error(res.result.res.msg || '创建合同失败');
      }
    } catch (error) {
      console.error('创建合同失败:', error);
      wx.hideLoading();
      this.setData({ isSubmitting: false });
      wx.showToast({
        title: error.message || '创建合同失败，请重试',
        icon: 'none',
        duration: 2000
      });
    }
  },
  
  // 打开签名画布
  openSignature(e) {
    const mode = (e && e.currentTarget && e.currentTarget.dataset && e.currentTarget.dataset.mode) || 'tenant';
    if (mode === 'tenant' && this.data.flow !== 'tenant') {
      return;
    }
    if (mode === 'landlord' && this.data.flow !== 'landlord') {
      return;
    }
    
    this.setData({
      showSignature: true,
      points: [],
      signatureMode: mode
    });

    wx.getSystemInfo({
      success: (res) => {
        const buttonWidth = 120;
        const headerHeight = 60;
        this.setData({
          canvasWidth: res.windowWidth - buttonWidth,
          canvasHeight: res.windowHeight - headerHeight
        });

        setTimeout(() => {
          const ctx = wx.createCanvasContext('signatureCanvas', this);
          ctx.setStrokeStyle('#000000');
          ctx.setLineWidth(3);
          ctx.setLineCap('round');
          ctx.setLineJoin('round');
          this.setData({ ctx });
        }, 100);
      }
    });
  },
  
  // 关闭签名画布
  closeSignature() {
    this.setData({
      showSignature: false,
      signatureMode: '',
      points: []
    });
  },
  
  // 阻止滚动
  preventMove() {
    return false;
  },
  
  // 触摸开始
  onTouchStart(e) {
    const { x, y } = e.touches[0];
    const ctx = this.data.ctx;
    if (!ctx) return;

    this.data.points = [{ x, y }];
    
    ctx.beginPath();
    ctx.moveTo(x, y);
    ctx.stroke();
    ctx.draw(true);
  },
  
  // 触摸移动
  onTouchMove(e) {
    const { x, y } = e.touches[0];
    const ctx = this.data.ctx;
    if (!ctx) return;

    const points = this.data.points;
    if (points.length > 0) {
      const lastPoint = points[points.length - 1];
      ctx.moveTo(lastPoint.x, lastPoint.y);
      ctx.lineTo(x, y);
      ctx.stroke();
      ctx.draw(true);
    }

    this.data.points.push({ x, y });
  },
  
  // 触摸结束
  onTouchEnd(e) {
    // 可以在这里做额外的处理
  },
  
  // 清除签名
  clearSignature() {
    const ctx = this.data.ctx;
    if (!ctx) return;

    ctx.clearRect(0, 0, this.data.canvasWidth, this.data.canvasHeight);
    ctx.draw(true);
    this.setData({
      points: []
    });
  },
  
  // 保存签名
  async saveSignature() {
    const ctx = this.data.ctx;
    if (!ctx) return;

    if (this.data.points.length === 0) {
      wx.showToast({
        title: '请先签名',
        icon: 'none'
      });
      return;
    }

    ctx.draw(true);
    
    setTimeout(() => {
      wx.canvasToTempFilePath({
        canvasId: 'signatureCanvas',
        success: async (res) => {
          const tempFilePath = res.tempFilePath;

          if (this.data.signatureMode === 'landlord') {
            this.setData({
              landlordSignatureTempPath: tempFilePath,
              landlordSignaturePreview: tempFilePath,
              showSignature: false,
              signatureMode: '',
              points: []
            });
            wx.showToast({
              title: '签名保存成功',
              icon: 'success'
            });
            return;
          }

          // 租客签名流程
          wx.showLoading({
            title: '保存中...',
            mask: true
          });

          try {
            const fileExtension = tempFilePath.split('.').pop();
            const cloudPath = `signatures/${Date.now()}-${Math.random().toString(36).substr(2, 9)}.${fileExtension}`;
            const uploadRes = await wx.cloud.uploadFile({
              cloudPath,
              filePath: tempFilePath
            });
            const signatureUrl = uploadRes.fileID;

            const updateRes = await wx.cloud.callFunction({
              name: 'contract',
              data: {
                apiType: 'updateContractTenantSignature',
                contractId: this.data.contractId,
                tenantSignature: signatureUrl
              }
            });

            wx.hideLoading();

            if (updateRes.result.res.code === 200) {
              await this.loadContractData();
              this.setData({
                showSignature: false,
                signatureMode: '',
                points: []
              });
              wx.showToast({
                title: '签名保存成功',
                icon: 'success'
              });
            } else {
              throw new Error(updateRes.result.res.msg || '保存失败');
            }
          } catch (error) {
            console.error('保存签名失败:', error);
            wx.hideLoading();
            wx.showToast({
              title: error.message || '保存失败，请重试',
              icon: 'none'
            });
          }
        },
        fail: (err) => {
          console.error('保存签名失败', err);
          wx.showToast({
            title: '保存失败，请重试',
            icon: 'none'
          });
        }
      }, this);
    }, 100);
  },

  copyContractId() {
    const contractId = this.data.createdContractId || this.data.contractId;
    if (!contractId) {
      wx.showToast({
        title: '合同ID不存在',
        icon: 'none'
      });
      return;
    }
    wx.setClipboardData({
      data: contractId,
      success: () => {
        wx.showToast({
          title: '合同ID已复制',
          icon: 'success'
        });
      }
    });
  },
  goTotenantSignature() {
    const contractId = this.data.createdContractId || this.data.contractId;
    if (!contractId) {
      wx.showToast({
        title: '合同ID不存在',
        icon: 'none'
      });
      return;
    }
    wx.navigateTo({
      url: `/pages/signature/index?contractId=${contractId}&flow=tenant`
    });
  },
  // 返回主页
  goToHome() {
    wx.reLaunch({
      url: '/pages/index/index'
    });
  },
  // 跳转到房间物品清点页面
  goToRoomItems() {
    const contractData = this.data.contractData || {};
    const roomId = contractData.roomId;
    
    if (!roomId) {
      wx.showToast({
        title: '房间信息缺失',
        icon: 'none'
      });
      return;
    }
    
    wx.navigateTo({
      url: `/pages/room-items/index?roomId=${roomId}`
    });
  },

  // 保存合同图片到相册 - 使用snapshot组件将页面内容生成长图片
  async saveContractToAlbum() {
    // 检查基础库版本（snapshot组件需要基础库3.0.1+）
    const systemInfo = await new Promise((resolve) => {
      wx.getSystemInfo({
        success: resolve
      });
    });

    const SDKVersion = systemInfo.SDKVersion || '';
    const versionArray = SDKVersion.split('.');
    const majorVersion = parseInt(versionArray[0]) || 0;
    const minorVersion = parseInt(versionArray[1]) || 0;
    const patchVersion = parseInt(versionArray[2]) || 0;

    // 检查是否支持snapshot（需要基础库3.0.1+）
    if (majorVersion < 3 || (majorVersion === 3 && minorVersion === 0 && patchVersion < 1)) {
      wx.showModal({
        title: '版本不支持',
        content: '截图功能需要微信基础库3.0.1及以上版本，请更新微信后重试',
        showCancel: false
      });
      return;
    }

    // 先检查相册权限
    const authRes = await new Promise((resolve) => {
      wx.getSetting({
        success: (res) => {
          if (res.authSetting['scope.writePhotosAlbum']) {
            resolve(true);
          } else {
            resolve(false);
          }
        },
        fail: () => resolve(false)
      });
    });

    if (!authRes) {
      // 请求相册权限
      const authorizeRes = await new Promise((resolve) => {
        wx.authorize({
          scope: 'scope.writePhotosAlbum',
          success: () => resolve(true),
          fail: () => resolve(false)
        });
      });

      if (!authorizeRes) {
        wx.showModal({
          title: '需要相册权限',
          content: '保存图片需要访问您的相册，请在设置中开启',
          showCancel: true,
          confirmText: '去设置',
          success: (modalRes) => {
            if (modalRes.confirm) {
              wx.openSetting();
            }
          }
        });
        return;
      }
    }

    // 隐藏保存按钮，避免出现在截图中
    this.setData({
      showSaveButton: false
    });

    wx.showLoading({
      title: '正在生成图片...',
      mask: true
    });

    try {
      // 等待一下确保按钮隐藏和节点渲染完成
      await new Promise(resolve => setTimeout(resolve, 500));

      // 使用snapshot组件的takeSnapshot API
      const query = wx.createSelectorQuery().in(this);
      const snapshotNode = query.select('#contractSnapshot');
      
      // 获取snapshot节点
      const nodeRes = await new Promise((resolve, reject) => {
        snapshotNode.node().exec((res) => {
          if (res && res[0] && res[0].node) {
            resolve(res[0].node);
          } else {
            reject(new Error('无法获取snapshot节点，请确保已启用Skyline渲染引擎'));
          }
        });
      });

      // 调用takeSnapshot方法截图
      nodeRes.takeSnapshot({
        type: 'arraybuffer', // 使用arraybuffer类型
        format: 'png',
        success: (res) => {
          console.log(res, '截图结果');
          
          // 使用用户数据路径保存文件
          const filePath = `${wx.env.USER_DATA_PATH}/contract_${Date.now()}.png`;
          console.log(filePath, '文件路径');
          
          // 获取文件系统管理器
          const fs = wx.getFileSystemManager();
          
          try {
            // 将arraybuffer写入文件
            fs.writeFileSync(filePath, res.data, 'binary');
            
            // 保存图片到相册
            wx.saveImageToPhotosAlbum({
              filePath: filePath,
              success: () => {
                // 显示保存按钮
                this.setData({
                  showSaveButton: true
                });
                wx.hideLoading();
                wx.showToast({
                  title: '已保存到相册',
                  icon: 'success',
                  duration: 2000
                });
              },
              fail: (err) => {
                // 显示保存按钮
                this.setData({
                  showSaveButton: true
                });
                console.error('保存图片失败', err);
                wx.hideLoading();
                if (err.errMsg && err.errMsg.includes('auth deny')) {
                  wx.showModal({
                    title: '需要相册权限',
                    content: '保存图片需要访问您的相册，请在设置中开启',
                    showCancel: true,
                    confirmText: '去设置',
                    success: (modalRes) => {
                      if (modalRes.confirm) {
                        wx.openSetting();
                      }
                    }
                  });
                } else {
                  wx.showToast({
                    title: '保存失败，请重试',
                    icon: 'none'
                  });
                }
              }
            });
          } catch (writeError) {
            // 显示保存按钮
            this.setData({
              showSaveButton: true
            });
            console.error('写入文件失败', writeError);
            wx.hideLoading();
            wx.showToast({
              title: '文件写入失败',
              icon: 'none'
            });
          }
        },
        fail: (err) => {
          // 显示保存按钮
          this.setData({
            showSaveButton: true
          });
          console.error('截图失败', err);
          wx.hideLoading();
          let errorMsg = '生成图片失败';
          if (err.errMsg && err.errMsg.includes('not support')) {
            errorMsg = '当前环境不支持截图功能，请确保已启用Skyline渲染引擎';
          }
          wx.showToast({
            title: errorMsg,
            icon: 'none',
            duration: 3000
          });
        }
      });
    } catch (error) {
      // 显示保存按钮
      this.setData({
        showSaveButton: true
      });
      console.error('保存合同失败:', error);
      wx.hideLoading();
      let errorMsg = '生成图片失败，请重试';
      if (error.message && error.message.includes('Skyline')) {
        errorMsg = error.message;
      }
      wx.showToast({
        title: errorMsg,
        icon: 'none',
        duration: 3000
      });
    }
  }
});
